// Code generated by MockGen. DO NOT EDIT.
// Source: internal/model/messages/incoming_msg.go

// Package mock_messages is a generated GoMock package.
package mock_messages

import (
	context "context"
	reflect "reflect"
	time "time"

	gomock "github.com/golang/mock/gomock"
	bottypes "github.com/ellavs/tg-bot-golang/internal/model/bottypes"
)

// MockMessageSender is a mock of MessageSender interface.
type MockMessageSender struct {
	ctrl     *gomock.Controller
	recorder *MockMessageSenderMockRecorder
}

// MockMessageSenderMockRecorder is the mock recorder for MockMessageSender.
type MockMessageSenderMockRecorder struct {
	mock *MockMessageSender
}

// NewMockMessageSender creates a new mock instance.
func NewMockMessageSender(ctrl *gomock.Controller) *MockMessageSender {
	mock := &MockMessageSender{ctrl: ctrl}
	mock.recorder = &MockMessageSenderMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockMessageSender) EXPECT() *MockMessageSenderMockRecorder {
	return m.recorder
}

// SendMessage mocks base method.
func (m *MockMessageSender) SendMessage(text string, userID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendMessage", text, userID)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMessage indicates an expected call of SendMessage.
func (mr *MockMessageSenderMockRecorder) SendMessage(text, userID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessage", reflect.TypeOf((*MockMessageSender)(nil).SendMessage), text, userID)
}

// ShowInlineButtons mocks base method.
func (m *MockMessageSender) ShowInlineButtons(text string, buttons []bottypes.TgRowButtons, userID int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ShowInlineButtons", text, buttons, userID)
	ret0, _ := ret[0].(error)
	return ret0
}

// ShowInlineButtons indicates an expected call of ShowInlineButtons.
func (mr *MockMessageSenderMockRecorder) ShowInlineButtons(text, buttons, userID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShowInlineButtons", reflect.TypeOf((*MockMessageSender)(nil).ShowInlineButtons), text, buttons, userID)
}

// MockUserDataStorage is a mock of UserDataStorage interface.
type MockUserDataStorage struct {
	ctrl     *gomock.Controller
	recorder *MockUserDataStorageMockRecorder
}

// MockUserDataStorageMockRecorder is the mock recorder for MockUserDataStorage.
type MockUserDataStorageMockRecorder struct {
	mock *MockUserDataStorage
}

// NewMockUserDataStorage creates a new mock instance.
func NewMockUserDataStorage(ctrl *gomock.Controller) *MockUserDataStorage {
	mock := &MockUserDataStorage{ctrl: ctrl}
	mock.recorder = &MockUserDataStorageMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockUserDataStorage) EXPECT() *MockUserDataStorageMockRecorder {
	return m.recorder
}

// GetUserCategory mocks base method.
func (m *MockUserDataStorage) GetUserCategory(ctx context.Context, userID int64) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserCategory", ctx, userID)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserCategory indicates an expected call of GetUserCategory.
func (mr *MockUserDataStorageMockRecorder) GetUserCategory(ctx, userID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserCategory", reflect.TypeOf((*MockUserDataStorage)(nil).GetUserCategory), ctx, userID)
}

// GetUserCurrency mocks base method.
func (m *MockUserDataStorage) GetUserCurrency(ctx context.Context, userID int64) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserCurrency", ctx, userID)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserCurrency indicates an expected call of GetUserCurrency.
func (mr *MockUserDataStorageMockRecorder) GetUserCurrency(ctx, userID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserCurrency", reflect.TypeOf((*MockUserDataStorage)(nil).GetUserCurrency), ctx, userID)
}

// GetUserDataRecord mocks base method.
func (m *MockUserDataStorage) GetUserDataRecord(ctx context.Context, userID int64, period time.Time) ([]bottypes.UserDataReportRecord, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserDataRecord", ctx, userID, period)
	ret0, _ := ret[0].([]bottypes.UserDataReportRecord)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserDataRecord indicates an expected call of GetUserDataRecord.
func (mr *MockUserDataStorageMockRecorder) GetUserDataRecord(ctx, userID, period interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserDataRecord", reflect.TypeOf((*MockUserDataStorage)(nil).GetUserDataRecord), ctx, userID, period)
}

// GetUserLimit mocks base method.
func (m *MockUserDataStorage) GetUserLimit(ctx context.Context, userID int64) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserLimit", ctx, userID)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserLimit indicates an expected call of GetUserLimit.
func (mr *MockUserDataStorageMockRecorder) GetUserLimit(ctx, userID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserLimit", reflect.TypeOf((*MockUserDataStorage)(nil).GetUserLimit), ctx, userID)
}

// InsertCategory mocks base method.
func (m *MockUserDataStorage) InsertCategory(ctx context.Context, userID int64, catName, userName string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertCategory", ctx, userID, catName, userName)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertCategory indicates an expected call of InsertCategory.
func (mr *MockUserDataStorageMockRecorder) InsertCategory(ctx, userID, catName, userName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertCategory", reflect.TypeOf((*MockUserDataStorage)(nil).InsertCategory), ctx, userID, catName, userName)
}

// InsertUserDataRecord mocks base method.
func (m *MockUserDataStorage) InsertUserDataRecord(ctx context.Context, userID int64, rec bottypes.UserDataRecord, userName string, limitPeriod time.Time) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertUserDataRecord", ctx, userID, rec, userName, limitPeriod)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertUserDataRecord indicates an expected call of InsertUserDataRecord.
func (mr *MockUserDataStorageMockRecorder) InsertUserDataRecord(ctx, userID, rec, userName, limitPeriod interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertUserDataRecord", reflect.TypeOf((*MockUserDataStorage)(nil).InsertUserDataRecord), ctx, userID, rec, userName, limitPeriod)
}

// SetUserCurrency mocks base method.
func (m *MockUserDataStorage) SetUserCurrency(ctx context.Context, userID int64, currencyName, userName string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetUserCurrency", ctx, userID, currencyName, userName)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetUserCurrency indicates an expected call of SetUserCurrency.
func (mr *MockUserDataStorageMockRecorder) SetUserCurrency(ctx, userID, currencyName, userName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserCurrency", reflect.TypeOf((*MockUserDataStorage)(nil).SetUserCurrency), ctx, userID, currencyName, userName)
}

// SetUserLimit mocks base method.
func (m *MockUserDataStorage) SetUserLimit(ctx context.Context, userID, limits int64, userName string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetUserLimit", ctx, userID, limits, userName)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetUserLimit indicates an expected call of SetUserLimit.
func (mr *MockUserDataStorageMockRecorder) SetUserLimit(ctx, userID, limits, userName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserLimit", reflect.TypeOf((*MockUserDataStorage)(nil).SetUserLimit), ctx, userID, limits, userName)
}

// MockExchangeRates is a mock of ExchangeRates interface.
type MockExchangeRates struct {
	ctrl     *gomock.Controller
	recorder *MockExchangeRatesMockRecorder
}

// MockExchangeRatesMockRecorder is the mock recorder for MockExchangeRates.
type MockExchangeRatesMockRecorder struct {
	mock *MockExchangeRates
}

// NewMockExchangeRates creates a new mock instance.
func NewMockExchangeRates(ctrl *gomock.Controller) *MockExchangeRates {
	mock := &MockExchangeRates{ctrl: ctrl}
	mock.recorder = &MockExchangeRatesMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockExchangeRates) EXPECT() *MockExchangeRatesMockRecorder {
	return m.recorder
}

// ConvertSumFromBaseToCurrency mocks base method.
func (m *MockExchangeRates) ConvertSumFromBaseToCurrency(currencyName string, sum int64) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConvertSumFromBaseToCurrency", currencyName, sum)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ConvertSumFromBaseToCurrency indicates an expected call of ConvertSumFromBaseToCurrency.
func (mr *MockExchangeRatesMockRecorder) ConvertSumFromBaseToCurrency(currencyName, sum interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConvertSumFromBaseToCurrency", reflect.TypeOf((*MockExchangeRates)(nil).ConvertSumFromBaseToCurrency), currencyName, sum)
}

// ConvertSumFromCurrencyToBase mocks base method.
func (m *MockExchangeRates) ConvertSumFromCurrencyToBase(currencyName string, sum int64) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConvertSumFromCurrencyToBase", currencyName, sum)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ConvertSumFromCurrencyToBase indicates an expected call of ConvertSumFromCurrencyToBase.
func (mr *MockExchangeRatesMockRecorder) ConvertSumFromCurrencyToBase(currencyName, sum interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConvertSumFromCurrencyToBase", reflect.TypeOf((*MockExchangeRates)(nil).ConvertSumFromCurrencyToBase), currencyName, sum)
}

// GetCurrenciesList mocks base method.
func (m *MockExchangeRates) GetCurrenciesList() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrenciesList")
	ret0, _ := ret[0].([]string)
	return ret0
}

// GetCurrenciesList indicates an expected call of GetCurrenciesList.
func (mr *MockExchangeRatesMockRecorder) GetCurrenciesList() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrenciesList", reflect.TypeOf((*MockExchangeRates)(nil).GetCurrenciesList))
}

// GetExchangeRate mocks base method.
func (m *MockExchangeRates) GetExchangeRate(currencyName string) (float64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetExchangeRate", currencyName)
	ret0, _ := ret[0].(float64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetExchangeRate indicates an expected call of GetExchangeRate.
func (mr *MockExchangeRatesMockRecorder) GetExchangeRate(currencyName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExchangeRate", reflect.TypeOf((*MockExchangeRates)(nil).GetExchangeRate), currencyName)
}

// GetMainCurrency mocks base method.
func (m *MockExchangeRates) GetMainCurrency() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMainCurrency")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetMainCurrency indicates an expected call of GetMainCurrency.
func (mr *MockExchangeRatesMockRecorder) GetMainCurrency() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMainCurrency", reflect.TypeOf((*MockExchangeRates)(nil).GetMainCurrency))
}
